﻿#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;

//int main()
//{
//	std::cout << "holle cpp!"<< std::endl;
//	std::cout << "good";
//	std::cout << " nice" << std::endl;
//	int v1 = 10, v2 = 10;
//	std::cin >> v1 >> v2;
//	std::cout << v1 + v2 << std::endl;
//
//}

//int main()
//{
//	int v1, v2;
//	//std::cin >> v1 >> v2;
//	//std::cout << "The sum of " << v1
//	//	<< " and "
//	//	<< v2 << " is "
//	//	<< v1 + v2;
//	std::cin >> v1 >> v2;
//	std::cout << "The sum of " << v1 << " and " << v2 << " is " << v1 + v2<<std::endl;
//
//	int sum = v1 * v2;
//	std::cout << "v1 * v2 = " << sum << std::endl;
//
//	return 0;
//}

/*
int main()
{
	//std::cout << "/* " << std::endl;
	//int x = 50, sum = 0;

	//while (x <= 100)
	//{
	//	sum += x;
	//	++x;
	//}

	//std::cout << sum << std::endl;

	int m = 10;
	while (m >= 0)
	{
		std::cout << m-- <<" ";
		--m;
	}

	int v1, v2;
	int flag = 1;//标识符
	std::cin >> v1 >> v2;
	while (v1 <= v2)
	{
		std::cout << v1++ << " ";
		flag = 0;
	}

	if (flag)
		std::cout << "范围不存在" << std::endl;
	
	std::cout << "Bey!";

	return 0;
}*/


//int main()
//{
//	int sum = 0;
//
//	for (int val = 1; val <= 10; ++val)
//	{
//		//val += 1;val在循环体中还是可以使用的，出了这个for循环的话，就不能使用了。
//		sum += val;
//	}
//
//	std::cout << "1-10的和为:" << sum << std::endl;
//
//	return 0;
//}

//int main()
//{
//	int sum = 0;
//
//	//-100到100的和
//	for (int val = -100; val <= 100; ++val)
//	{
//		sum += val;
//	}
//
//	std::cout << "-100~100 sum = " << sum << std::endl;
//
//	return 0;
//}

//int main()
//{
//	int sum = 0, val = 0;
//
//	std::cout << "输入ctrl+z结束输入" << std::endl;
//
//	while (std::cin >> val)
//	{
//		sum += val;
//	}
//
//	std::cout << "val sum = " << sum << std::endl;
//
//	return 0;
//}

//int main()
//{
//
//	int valarr = 0, val = 0;
//
//	if (std::cin >> valarr)
//	{
//		int count = 1;//计数器
//		
//		while (std::cin >> val)
//		{
//			if (valarr == val)
//				count++;
//			else
//			{
//				std::cout << valarr << "occurs" << count << std::endl;
//				valarr = val;//更新valarr的值
//				count = 1;
//			}
//		}
//
//		std::cout << valarr << "occurs" << count << std::endl;
//	}
//
//	//要处理更复杂的数据，比如12 12 13 12 10
//	//就先利用排序，再使用上述的统计方式，效率较高一些
//	return 0;
//}

//
//int main()
//{
//	std::cout << "请输入两个整数" << std::endl;
//
//	int a, b;
//	
//	std::cin >> a >> b;
//	
//	//取较大的一个
//	int max = 0;
//	int min = 0;
//	if (a > b)
//	{
//		max = a;
//		min = b;
//	}
//	else
//	{
//		max = b;
//		min = a;
//	}
//
//	while (max >= min)
//	{
//		std::cout << min++ << " ";
//	}
//
//	return 0;
//}


int& fun()
{
	static int n = 0;//静态区
	n++;

	return n;
}
//返回的是n的别名
//int main()
//{
//	int ret = fun();//相当于ret = n;
//
//	//ret的改变并不会引起n的改变
//	std::cout << ++ret << std::endl;
//
//	fun();
//	return 0;
//}

//﻿class A
//{
//public:
//  A(int a)
//	:_a1(a)
//	,_a2(_a1)
//  {}
//
//  void Print()
//  {
//	cout << _a1 << " " << _a2 << endl;
//  }
//
//private:
//  int _a2;
//  int _a1;
//}
//
//
//
//int main()
//{
//	A aa(1);
//	aa.Print();
//
//	return 0;
//}

//typedef struct st//学生类
//{
//	int age;
//	char name[20];
//	int hight;
//}st;
//
//class STD
//{
//public:
//	void Init(int a, int h, const char* p)
//	{
//		age = a;
//		hight = h;
//		_a = p;
//	}
//	void print()
//	{
//		std::cout << age << " " << hight << " " << _a << std::endl;
//	}
//	int age;
//	int hight;
//	const char* _a;
//};
//int main()
//{
//	STD s;
//	s.Init(12, 178, "zhangsan");
//	s.print();
//
//	/*st s = {12, "小明", 178};
//	printf("%d %s %d", s.age, s.name, s.hight);*/
//
//	return 0;
//}

//class A
//{
//public:
//	A()
//	{
//		std::cout << "gouzaoA" << std::endl;
//	}
//	~A()
//	{
//		std::cout << "xigouA" << std::endl;
//	}
//private:
//	int a;
//};
//
//class B
//{
//public:
//	B()
//	{
//		std::cout << "gouzaoB" << std::endl;
//	}
//	~B()
//	{
//		std::cout << "xigouB" << std::endl;
//	}
//private:
//	int a;
//};
//
//A a;
//B b;
//void F()
//{
//	A a;
//	B b;
//}

//string& operator=(const string& s)
//{
//	if (this != &s)
//	{
//		delete[] str;
//		_str = new char[s.capacity + 1];
//		if (_str)
//		{
//			strcpy(_str, s._str);
//			_size = s._size;
//			_capacity = s._capacity;
//		}
//		else
//			exit(-1);
//	}
//	return *this;
//}

//using namespace std;
//int getmonthday(int y, int m)
//{
//	int arr[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
//	if (m == 2 && ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0)))
//	{
//		return 29;
//	}
//	else
//	{
//		return arr[m];
//	}
//}
//
//int main() {
//	int y, d, m = 1;
//
//	int x = 0, n = 0;
//
//	while (cin >> y >> d)
//	{
//		while (x != d)
//		{
//			++x;
//			++n;
//			if (n > getmonthday(y, m))
//			{
//				++m;
//				n = 1;
//				if (m == 13)
//				{
//					++y;
//					m = 1;
//				}
//			}
//		}
//
//
//		printf("%d-%02d-%02d\n", y, m, n);
//		m = 1, x = 1, n = 1;
//
//	}
//	return 0;
//}


#include <string.h>
class Student
{
	friend void operator<<(ostream& out, const Student& s);
public:
	Student(int age, int id, const char* name)
	{
		_age = age;
		_id = id;
		_name = new char[strlen(name) + 1];
		//const传给非const的类型是不被允许的，通过开辟新的空间拷贝的方式去实现_name
		strcpy(_name, name);
	}

	~Student()
	{
		_age = _id = 0;
		delete[] _name;
		_name = nullptr;
	}

	void print()
	{
		cout << _age << " " << _id << " " << _name << endl;
	}
private:
	int _age;
	int _id;
	char* _name;
};


void operator<<(ostream& out, const Student& s)
{
	out << s._age << " " << s._id << " " << s._name << endl;
}

//int main()
//{
//	Student s1(18, 12345, "zhangsan");
//	//s1.print();
//
//	//cout << s1;
//
//	int a = 3;
//	int b = a >> 1;
//	cout << b << endl;
//
//	return 0;
//}


//class Solution {
//public:
//	int StrToInt(string str) {
//		int ret = 0;
//		int flag = 1;//正数
//		for (size_t i = 0; i < str.size(); ++i)
//		{
//			if (str[i] == '+' || str[i] == '-')
//			{
//				if (i != 0) return 0;
//				if (str[i] == '-')
//					flag = -1;//负数
//			}
//			else if (str[i] >= '0' && str[i] <= '9')
//				ret = ret * 10 + str[i] - '0';
//			else
//				return 0;
//		}
//		return ret = ret * flag;
//	}
//};

//int main()
//{
//	Solution s;
//	long long ret = s.StrToInt("23465654");
//
//	cout << ret << endl;
//
//	return 0;
//}


//#include <iostream>
//using namespace std;
//
//int main() {
//	string s;
//	char ch = cin.get();
//
//	while (ch != '\n')
//	{
//		s += ch;
//		ch = cin.get();
//	}
//
//	int cnt = 0;
//	int i = s.size() - 1;
//	while (s[i] != ' ' && i >= 0)
//	{
//		cnt++;
//		i--;
//	}
//
//	printf("%d", cnt);
//}


//class Solution {
//public:
//	bool isPalindrome(string s) {
//		string str;
//		if (s.size() == 0)
//			return true;
//
//		for (auto ch : s)
//		{
//			if (ch >= 'A' && ch <= 'Z')
//			{
//				ch = ch + 32;
//				str += ch;
//			}
//			else if (ch >= 'a' && ch <= 'z')
//			{
//				str += ch;
//			}
//		}
//
//		//判断是否回文
//		int left = 0;
//		int right = str.size() - 1;
//
//		while (left < right)
//		{
//			if (str[left] != str[right])
//				return false;
//			left++;
//			right--;
//		}
//		return true;
//}
//};
//
//class Solution {
//	void myreverse(string& s, int left, int right)
//	{
//		while (left < right)
//		{
//			char ch = s[left];
//			s[left] = s[right];
//			s[right] = ch;
//			left++;
//			right--;
//		}
//	}
//public:
//	string reverseStr(string s, int k) {
//		size_t cnt = 0;
//
//		int i = 0, x = 0;
//		while (s[i] != '\0')
//		{
//			cnt++;
//			if (cnt == 2 * k)
//			{
//				myreverse(s, x, x + k - 1);
//				cnt = 0;
//				x = i+1;
//			}
//			i++;
//		}
//
//		if (cnt < k)
//		{
//			myreverse(s, x, i - 1);
//		}
//		else if (cnt >= k && cnt < 2 * k)
//		{
//			myreverse(s, x, x + k - 1);
//		}
//		return s;
//	}
//};


#include <string>
//class Solution {
//public:
//	string multiply(string num1, string num2) {
//		string str;
//		int n = 0;//进位数
//		//采用进位的办法去解决
//		//先找长度小的num
//		string max = num1;
//		string min = num2;
//		if (num1.size() < num2.size())
//		{
//			max = num2;
//			min = num1;
//		}
//
//		int i = 0;
//		int j = min.size() - 1;
//		long long sum = 0;
//		long long sum2 = 0;
//
//		int q = -1;
//		while (j >= 0)
//		{
//			while (i < max.size())
//			{
//				int x = ((max[i] - '0') * (min[j] - '0'));
//				if (x > 9)
//				{
//					sum = sum * 10 + x;
//				}
//				else
//				{
//					sum = sum * 10 + x;
//				}
//				i++;
//			}
//			int n = ++q;
//			while (n)
//			{
//				sum *= 10;
//				n--;
//			}
//
//			sum2 += sum;
//			j--;
//			sum = i = 0;
//		}
//
//		//sum2就是计算出来的结果--int
//		str = to_string(sum2);
//		return str;
//}
//};//测试用例不通过，数据溢出问题--换思路

//int main()
//{
//	int arr[] = { 1,2,3,4,5,6 };
//	int* p1 = &arr[3];
//	int* p2 = &arr[6];
//
//	cout << p2 - p1 << endl;
//
//	return 0;
//}

//#include <vector>
//int main()
//{
//	vector<int> v1;
//	v1.push_back(100);
//	v1.push_back(300);
//	v1.push_back(300);
//	v1.push_back(500);
//
//	vector<int>::iterator it = v1.begin();
//	for (it; it != v1.end(); ++it)
//	{
//		if (*it == 300)
//		{
//			//it = v1.erase(it);
//			v1.erase(it);//野指针的使用，it的指向的空间已经被释放了，但是没有it没有更新位置
//		}
//	}
//
//	for (auto e : v1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	return 0;
//}

//#include <vector>
//int main()
//{
//	int ar[] = { 1,2,3,4,5,6,7,8,9,10 };
//	int n = sizeof(ar) / sizeof(int);
//	vector<int> v(ar, ar + n);
//
//	cout << v.size() << ":" << v.capacity() << endl;
//	v.reserve(100);
//	v.resize(20);
//	for (auto e : v)
//	{
//		cout << e;
//	}
//	cout << endl;
//	cout << v.size() << ":" << v.capacity() << endl;
//	v.reserve(50);
//	v.resize(5);
//	for (auto e : v)
//	{
//		cout << e;
//	}
//	cout << endl;
//
//	cout << v.size() << ":" << v.capacity() << endl;
//
//	return 0;
//}

//#include <vector>
//int main()
//{
//	vector<int> v(3,1);
//	//int a = v[3];
//
//	int b = v.at(3);
//
//	return 0;
//}

//#include <list>
//int main()
//{
//	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
//	list<int> mylist(arr, arr + sizeof(arr) / sizeof(arr[0]));
//
//	list<int>::iterator pos = find(mylist.begin(), mylist.end(), 5);
//	list<int>::iterator it = mylist.begin();
//	//了解reverse的源代码
//	reverse(mylist.begin(), pos);
//	while (it != mylist.end())
//	{
//		cout << *it++ << " ";
//	}
//	cout << endl;
//
//	reverse(pos, mylist.end());//pos是不跟着链表的5走的，5交换后，pos的位置不会改变
//	//所以这次逆置之后，pos就位置的val就是9了
//	it = mylist.begin();
//	while (it != mylist.end())
//	{
//		cout << *it++ << " ";
//	}
//	cout << endl;
//	return 0;
//}

//#include <vector>
//int main()
//{
//	vector<int> v1(3,0);
//
//	vector<int>::iterator it = v1.begin();
//	it = v1.insert(it, 1);
//	it = v1.insert(it, 1);
//	it = v1.insert(it, 1);
//	it = v1.insert(it, 1);
//
//	while (it != v1.end())
//	{
//		cout << *it++ << " ";
//	}
//	cout << endl;
//	return 0;
//}

//struct ListNode {
//	int val;
//	struct ListNode* next = NULL;
//};
//
//struct ListNode* buyListNode(int x)
//{
//	struct ListNode* newnode = new struct ListNode;
//	newnode->val = x;
//	newnode->next = nullptr;
//
//	return newnode;
//}

//class Solution {
//public:
//	ListNode* reverseBetween(ListNode* head, int m, int n) {
//		ListNode* res = new ListNode(-1); //加个表头
//		res->next = head;
//		ListNode* pre = res; //前序节点
//		ListNode* cur = head; //当前节点
//		for (int i = 1; i < m; i++) { //找到m
//			pre = cur;
//			cur = cur->next;
//		}
//		for (int i = m; i < n; i++) { //从m反转到n
//			ListNode* temp = cur->next;
//			cur->next = temp->next;
//			temp->next = pre->next;
//			pre->next = temp;
//		}
//		return res->next; //返回去掉表头
//	}
//};


//class Solution {
//public:
//	ListNode* reverseKGroup(ListNode* head, int k) {
//		int count = 0;
//		ListNode* phead = new ListNode(0);//头结点
//		phead->next = head;
//		ListNode* pre = phead;//cur的前一个指针
//		ListNode* cur = head;
//
//		while (cur != nullptr)
//		{
//			count++;
//			cur = cur->next;
//		}
//		int n = count / k;//反转的组数
//
//		cur = head;
//		for (int i = 0; i < n; ++i)
//		{
//			//进行反转
//			for (int f = 1; f < k; ++f)
//			{
//				ListNode* temp = cur->next;
//				cur->next = temp->next;
//				temp->next = pre->next;
//				pre->next = temp;
//			}
//			pre = cur;
//			cur = cur->next;
//		}
//		return phead->next;
//	}
//};

//int main()
//{	
//	struct ListNode* n1 = buyListNode(1);
//	struct ListNode* n2 = buyListNode(2);
//	struct ListNode* n3 = buyListNode(3);
//	struct ListNode* n4 = buyListNode(4);
//	struct ListNode* n5 = buyListNode(5);
//	n1->next = n2;
//	n2->next = n3;
//	//n3->next = n4;
//	//n4->next = n5;
//
//	Solution s;
//	s.reverseKGroup(n1, 3);
//
//	return 0;
//}


//#include <queue>
//int main()
//{
//	priority_queue<int> a;
//	priority_queue<int, vector<int>, greater<int> > c;
//	priority_queue<string> b;
//
//	for (int i = 0; i < 5; i++)
//	{
//		a.push(i);
//		c.push(i);
//	}
//
//	while (!a.empty())
//	{
//		cout << a.top() << ' ';
//		a.pop();
//	}
//	cout << endl;
//	while (!c.empty())
//	{
//		cout << c.top() << ' ';
//		c.pop();
//	}
//	cout << endl;
//
//	b.push("abc");
//	b.push("abcd");
//	b.push("cbd");
//
//	while (!b.empty())
//	{
//		cout << b.top() << ' ';
//		b.pop();
//	}
//	cout << endl;
//	return 0;
//}

//#include <vector>
//#include <list>
//#include <deque>
//
//int main()
//{
//	deque<int> cont = { 1, 2, 3, 4, 5 };
//	deque<int>::iterator iter, tempIt;
//
//	for (iter = cont.begin(); iter != cont.end();)
//	{
//		tempIt = iter;
//		++iter;
//		cont.erase(tempIt);
//	}
//}

//#include <iostream>
//using namespace std;
//
//int main()
//{
//	string s1("abcd");
//	string s2("abcd");
//	//cin >> s1 >> s2;
//	/*getline(cin, s1);
//	getline(cin, s2);*/
//
//	string::iterator i = s1.begin();
//	int flag = 0;
//	while (i != s1.end())
//	{
//		int j = 0;
//		while (j < s2.size())
//		{
//			if (*i == s2[j])
//			{
//				i = s1.erase(i, i+1);
//				flag = 1;
//				break;
//			}
//			j++;
//		}
//		if(!flag)
//			i++;
//	}
//
//	cout << s1;
//	return 0;
//}


//#include <iostream>
//#include <algorithm>
//#include <vector>
//using namespace std;
//
//int main()
//{
//	vector<int> v;
//	int n = 0;
//	cin >> n;//组数
//
//	for (int i = 0; i < 3 * n; ++i)
//	{
//		int x = 1;
//		cin >> x;
//		v.push_back(x);
//	}
//
//	//排序
//	sort(v.begin(), v.end(), greater<int>());
//
//	int sum = 0;//水平值总和最大值
//	int i = v.size() - 2;
//	while (n--)
//	{
//		sum += v[i];
//		i -= 2;
//	}
//
//	cout << sum << endl;
//	return 0;
//}

//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	string s_out;
//	string s;
//	cin >> s;
//
//	int cnt = 0;
//	int n = 0;
//	int x, y;
//
//	int j = 0;
//	for (int i = 0; i < s.size(); ++i)
//	{
//		int flag = 0;
//		if (s[i] >= '0' && s[i] <= '9')
//		{
//			j = i;
//			flag = 1;
//			while (s[j] >= '0' && s[j] <= '9')
//			{
//				j++;
//				n++;
//			}
//			if (n > cnt)
//			{
//				cnt = n;
//				x = i;
//				y = j;//开区间
//			}
//			n = 0;
//		}
//		if (flag) i = j - 1;
//	}
//
//	for (int i = x; i < y; ++i)
//	{
//		cout << s[i];
//	}
//	return 0;
//}

//#include <iostream>
//#include <algorithm>  
//using namespace std;
//
//int main()
//{
//	char s[1000] = { 0 };
//	int N, M;
//	cin >> M >> N;
//
//	int i = 0;
//	if (N >= 2 && N <= 16)
//	{
//		while (M)
//		{
//			int x = M % N;
//			if (x > 9)
//			{
//				switch (x)
//				{
//				case 10:
//					s[i++] = 'A';
//					break;
//				case 11:
//					s[i++] = 'B';
//					break;
//				case 12:
//					s[i++] = 'C';
//					break;
//				case 13:
//					s[i++] = 'D';
//					break;
//				case 14:
//					s[i++] = 'E';
//					break;
//				case 15:
//					s[i++] = 'F';
//					break;
//				}
//			}
//			else
//				s[i++] = x + '0';
//			M = M / N;
//		}
//	}
//	reverse(s, s + i);
//
//	for (int j = 0; j < i; j++)
//	{
//		printf("%c", s[j]);
//	}
//
//	return 0;
//}


//class A
//{
//private:
//	static int a;
//	const static int b = 0;//虽然static修饰的变量不能给初始值，但是被const修饰的静态变量却可以
//	//因为const修饰的变量都会别初始化列表初始化
//	static const int c = 0;
//};
//int A::a = 0;
//
//int main()
//{
//	return 0;
//}


//class B;
//class A
//{
//	friend void print(A a, B b);
//	friend B;
//	int a;
//public:
//	A(int v = 0)
//		:a(v)
//	{}
//};
////A类的友元函数不是B类的友元函数，必须在B类种也声明一下改函数也是B类的友元函数
////友元函数不具有传递性
//
//class B
//{
//	friend void print(A a, B b);
//	int a;
//public:
//	B(int v = 0)
//		:a(v)
//	{}
//
//	void fun()
//	{
//		print(A(10), B(20));
//	}
//};
//
//void print(A a, B b)
//{
//	cout << "nihao--" << a.a << endl;
//	cout << b.a << "nihao--" << a.a << endl;
//}

class person
{
public:
	person(int a = 0)
		:_age(a)
	{}

	void print()
	{
		cout << "A" << endl;
	}
private:
	int _age = 0;
	short _a = 0;
	int _b = 0;


public:
	//内部类天生是外部类的友元类
	//1. 内部类可以定义在外部类的public、protected、private都是可以的。
	//2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象 / 类名。
	//3. sizeof(外部类) = 外部类，和内部类没有任何关系。
	class student
	{
	public:
		student(int n = 0)
			:_id(n)
		{}

		void print(person p)
		{
			cout << _id << endl;
			cout << p._age << endl;
		}
	private:
		int _id;
	};
};

//class student
//{
//public:
//	student(int n = 0)
//		:_id(n)
//	{}
//
//	void fun(int age)
//	{
//		_p._age = age;
//	}
//
//	void print()
//	{
//		cout << _id << " " << _p._age << endl;
//	}
//private:
//	int _id;
//	person _p;
//};

//int main()
//{
//	/*A a(10);
//	B b;
//	b.fun();*/
//	//print(a, b);
//
//	/*student s(1234);
//	s.fun(10);
//	s.print();*/
//
//	person::student s(1234);
//	s.print(person(10));
//
//	//结构体对齐规则
//	cout << sizeof(person) << endl;
//	return 0;
//}
